package com.ruoyi.learn.java.collection;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;

public class CollectionDemo {
    public static void main(String[] args) {
        System.out.println("=== ArrayList 示例 ===");
        testArrayList();

        System.out.println("\n=== LinkedList 示例 ===");
        testLinkedList();

        System.out.println("\n=== HashSet 示例 ===");
        testHashSet();

        System.out.println("\n=== TreeSet 示例 ===");
        testTreeSet();

        System.out.println("\n=== HashMap 示例 ===");
        testHashMap();

        System.out.println("\n=== TreeMap 示例 ===");
        testTreeMap();

        System.out.println("\n=== Queue 示例 ===");
        testQueue();

        System.out.println("\n=== 线程安全集合示例 ===");
        testConcurrentCollections();
    }

    // ArrayList 示例（动态数组）
    public static void testArrayList() {
        List<String> list = new ArrayList<>();

        // 添加元素
        list.add("Apple");
        list.add("Banana");
        list.add("Apple"); // 允许重复
        list.add(1, "Orange"); // 指定索引插入

        System.out.println("元素列表: " + list);
        System.out.println("索引2的元素: " + list.get(2));

        // 删除元素
        list.remove("Apple"); // 删除第一个匹配元素
        list.remove(0); // 删除指定索引元素

        System.out.println("删除后: " + list);
        System.out.println("是否包含Banana: " + list.contains("Banana"));

        // 遍历
        System.out.print("遍历元素: ");
        for (String fruit : list) {
            System.out.print(fruit + " ");
        }
        System.out.println();
    }

    // LinkedList 示例（双向链表）
    public static void testLinkedList() {
        LinkedList<String> list = new LinkedList<>();

        // 添加元素
        list.add("First");
        list.addLast("Last");
        list.addFirst("Header");

        System.out.println("链表元素: " + list);

        // 队列操作
        list.offer("OfferElement"); // 尾部添加
        System.out.println("出队元素: " + list.poll()); // 头部移除

        // 栈操作
        list.push("StackTop"); // 头部添加
        System.out.println("出栈元素: " + list.pop()); // 头部移除

        System.out.println("最终链表: " + list);
    }

    // HashSet 示例（无序、去重）
    public static void testHashSet() {
        Set<String> set = new HashSet<>();

        // 添加元素
        set.add("Dog");
        set.add("Cat");
        set.add("Dog"); // 重复元素，不会添加
        set.add("Bird");

        System.out.println("集合元素: " + set); // 无序
        System.out.println("是否包含Cat: " + set.contains("Cat"));

        // 删除元素
        set.remove("Bird");

        // 遍历
        System.out.print("遍历元素: ");
        for (String animal : set) {
            System.out.print(animal + " ");
        }
        System.out.println();
    }

    // TreeSet 示例（有序、去重）
    public static void testTreeSet() {
        Set<Integer> set = new TreeSet<>();

        // 添加元素
        set.add(30);
        set.add(10);
        set.add(20);
        set.add(10); // 重复元素，不会添加

        System.out.println("排序后集合: " + set); // 自然排序（升序）

        // 自定义排序（降序）
        Set<Integer> descSet = new TreeSet<>((a, b) -> b - a);
        descSet.addAll(set);
        System.out.println("降序排序: " + descSet);
    }

    // HashMap 示例（键值对、无序）
    public static void testHashMap() {
        Map<String, Integer> map = new HashMap<>();

        // 添加键值对
        map.put("Apple", 10);
        map.put("Banana", 20);
        map.put("Apple", 15); // 覆盖已有key的值

        System.out.println("Map内容: " + map);
        System.out.println("Apple的值: " + map.get("Apple"));

        // 判断key/value是否存在
        System.out.println("是否包含Banana: " + map.containsKey("Banana"));
        System.out.println("是否包含值20: " + map.containsValue(20));

        // 遍历
        System.out.print("所有key: ");
        for (String key : map.keySet()) {
            System.out.print(key + " ");
        }
        System.out.println();

        System.out.print("所有键值对: ");
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            System.out.print(entry.getKey() + "=" + entry.getValue() + " ");
        }
        System.out.println();
    }

    // TreeMap 示例（键有序）
    public static void testTreeMap() {
        Map<String, String> map = new TreeMap<>(); // 按key自然排序（字母顺序）

        map.put("C", "Third");
        map.put("A", "First");
        map.put("B", "Second");

        System.out.println("按key排序: " + map);

        // 自定义排序（反转字母顺序）
        Map<String, String> customMap = new TreeMap<>((a, b) -> b.compareTo(a));
        customMap.putAll(map);
        System.out.println("自定义排序: " + customMap);
    }

    // Queue 示例（队列）
    public static void testQueue() {
        Queue<String> queue = new LinkedList<>();

        // 入队
        queue.offer("First");
        queue.offer("Second");
        queue.offer("Third");

        System.out.println("队列元素: " + queue);
        System.out.println("队首元素: " + queue.peek());

        // 出队
        while (!queue.isEmpty()) {
            System.out.println("出队: " + queue.poll());
        }
    }

    // 线程安全集合示例
    public static void testConcurrentCollections() {
        // 线程安全List
        List<String> safeList = new CopyOnWriteArrayList<>();
        safeList.add("A");
        safeList.add("B");
        System.out.println("CopyOnWriteArrayList: " + safeList);

        // 线程安全Map
        Map<String, Integer> safeMap = new ConcurrentHashMap<>();
        safeMap.put("One", 1);
        safeMap.put("Two", 2);
        System.out.println("ConcurrentHashMap: " + safeMap);
    }
}

